
#include "main.h"
 
#include "public.h"




void phase_sample(void)  //-----------------------相位采集----------------------
{
  s32 s32av_Sum;
  u16 i;  
//---------------------连续监测几次相位-----------------------------------------  

    
  gc.s32phase_check_filish=0;    
  gc.u8phase_check_index=0;                           //相位检测值指针
  gc.u8phase_check_times=3;                           //连续相位检测次数      

  
  while (  gc.u8phase_check_index < gc.u8phase_check_times  ) //采多次相位值
  {
    gc.u8work_check_statue=0;       
    phase_check( ); 
    gc.s32phase_check_val[gc.u8phase_check_index] = gc.s32time14cnt_val;    
    gc.u8phase_check_index++;  
  }
  gc.s32phase_check_filish =1;//完成采样 

//------------------------------------------------------------------------------

//-----------------------数据后处理 ,判断数据的有效性 并求平均值------------------

  if (  gc.s32phase_check_filish ==1  )//完成采样 
  {
    gc.s32phase_check_filish =0;
    
    gc.s32phase_check_val_min =2000;
    gc.s32phase_check_val_max =-2000; 
    s32av_Sum=0;
    
    for ( i=0 ; i<gc.u8phase_check_times;i++ )
    {
      if(  gc.s32phase_check_val[i] >=3500   )              //无效
      {
       gc.u8phase_check_val_yn=0;   //数据在异常范围
       i=gc.u8phase_check_times;          //跳出循环
      }
      else
      {
       gc.u8phase_check_val_yn=1;   //数据在正常范围
      }

      if(  gc.s32phase_check_val[i] <=gc.s32phase_check_val_min  )
      {
        gc.s32phase_check_val_min =gc.s32phase_check_val[i];
      }
      if(  gc.s32phase_check_val[i] >=gc.s32phase_check_val_max  )
      {
        gc.s32phase_check_val_max =gc.s32phase_check_val[i];
      }      
      if (gc.s32phase_check_val_max - gc.s32phase_check_val_min >50 ) //相位值不稳定 退出
      {
       gc.u8phase_check_val_yn=0;   //数据在异常范围
       i=gc.u8phase_check_times;          //跳出循环      
      }

      s32av_Sum +=gc.s32phase_check_val[i];
    }
    gc.s32phase_check_av_val=s32av_Sum/gc.u8phase_check_times;            
    s32av_Sum=0;
  }
}

void save_f_ph( void ) //保存相位和频率
{
  u16  i;
  //----------------------移动存储过程相位--------------------------------------------  
    for( i=150; i>1; i-- )
    {
      gc.s32phase_old[i-1] = gc.s32phase_old[i-2];
    }   
    gc.s32phase_old[0] =gc.s32phase_check_av_val;
    

//----------------------存储过程频率------------------------------------------   
    for( i=150; i>1; i-- )
    {
      gc.u32Freq_old[i-1] = gc.u32Freq_old[i-2];
    }   
    gc.u32Freq_old[0] =gc.u32Current_freq;  
}


void over_power( void ) //超过设定功率
{
//    gc.u16cph_cnt=0;
  
  if(  gc.u8over_power_F==0 ) //在过功率时置标志，只置一次
  {
    gc.u8over_power_F=1;       
  }

  
  if (  gc.u32Current_freq < gc.work_span_H )
  {
    gc.u32Current_freq +=gc.Freq_adj_val; //0.5hz
    if (   gc.u32Current_freq >= gc.work_span_H  )                      //频率调到头了
    {
      gc.u32Current_freq = gc.work_span_H;
      
      if (  gc.s32work_FeedCurrent >  gc.s16power_set_inter_val*15/10  )        //可在这增加延时关机   
      {
        WAVE_OUTPUT_cmd( DISABLE);
        E_VALVE_cmd( DISABLE );
        
        err_handle(10015);        //当功率过大，频率调到频率上限，功率仍然超过设定频率50%时结束焊接
        
        gc.u8work_ovp_F=0;          // 过功率保护标志     
        gc.Work_cmd =0;             //
      }
    } 
  }
  
  gc.u8workscan_en=1;
  
  
    
//----------------在发波过程中第一次触到设定功率---------------------------------
//    if(  gc.u8work_scan_oc1_freq_updata_F==0 )
//    {
//      gc.u8work_scan_oc1_freq_updata_F=1;     //工作时向下扫频 ，第一次触碰到设定功率点时的频率更新标志    
//      gc.s32work_scan_oc1_freq=gc.u32Current_freq;     //工作时向下扫频 ，第一次触碰到设定功率点时的频率 
//
////----------------在调试模式下 在这里要先判断振子在压紧后频率会不会偏离正常范围内可以调整频率偏移量，否则不调-------------------      
////test 状态时保存这个是否的频率值，并判断超声波振子是否压力合适，条件是压紧后工作频率是否高于追频20hz左右
//
//      gc.s16work_solder_freq_error=gc.s32work_scan_oc1_freq-gc.first_scan_Result_freq-gc.s32series_parallel_freq_error;       //相对串联谐振点的频率偏差振子压力是高低  
//      
//      if (  gc.s16work_solder_freq_error  < 200 &&  gc.s16work_solder_freq_error  > -100  && gc.s32phase_check_av_val<0  &&  gc.u8phase_check_val_yn==1  )  //正常范围  +20hz-10hz
//      {
//        gc.s32work_freq_err=gc.s32work_scan_oc1_freq-gc.first_scan_Result_freq-gc.s32work_freq_offset;  //调整频率偏移值到频率中心
//        
//        if ( gc.s32work_freq_err>0  )
//        {
//          gc.s32work_freq_offset += gc.s32work_freq_err;
//        }
//        else if ( gc.s32work_freq_err<0 )
//        {
//          gc.s32work_freq_offset += gc.s32work_freq_err;
//        }
//        gc.s8work_freq_offset_adj_F=1;   //工作频率修正值 更新标志 0未修正过 ，   1未修正过      
//      }
//
////--------------------------打印错误信息---------------------------------      
//      else if (  gc.s16work_solder_freq_error  >= 400 )//振子太偏紧
//      {
//        err_handle(10019);         //报错误代码 振子压偏紧 
//
//      }
//      else if (  gc.s16work_solder_freq_error  <= -100 )//振子太偏松
//      {
//        err_handle(10020);       //报错误代码 振子压偏松
//      }         
//
//      else if (  gc.s16work_solder_freq_error  >= 200 )//振子压偏紧
//      {
//        err_handle(10016);         //报错误代码 振子压偏紧 
//
//      }
//      else if (  gc.s16work_solder_freq_error  <= -200 )//振子压偏松
//      {
//        err_handle(10017);       //报错误代码 振子压偏松
//      }       
////----------------------------------------------------------------------
//       
//    }
////--------------------------------------------------------------------------------     

//----------------------不是第一次过功率，调高工作频率--------------------------------------- 

}


void Fscan_or_phaseadj( void )//扫频或调相
{
//    gc.u16cph_cnt=0;

//-------------------------降频扫描---------------------------------------------   
      if (    gc.u8workscan_en==1   )  //降频扫描位
      {
        gc.u32Current_freq -=gc.Freq_adj_val;//   降频 
        
        
//------------------------------------ 找最大值并记录 ---------------------------      
        gc.u32work_scan_av_current_new = ( gc.u32Adc_CH4[0] +gc.u32Adc_CH4[1] )/2;
        if (gc.u32work_scan_av_current_new >= gc.u32work_scan_av_current_max )// 找最大值并记录同时记录频率
        {
          gc.u32work_scan_av_current_max = gc.u32work_scan_av_current_new;
          gc.u32work_scan_maxcurrent_freq = gc.u32Current_freq;
        }          
      }
   
    
//-----------------------------扫完，没扫到谐振点处理---------------------------    

      if(  gc.u32Current_freq <= gc.work_span_L )//gc.s32work_ref_freq   ) //扫到基准频率还未找到正确相位就停在基准频率工作
      {
        err_handle(10014);        //报错   扫不到谐振点，可能是压死了，或异常
        
//--------------增加扫到头以后一功率最大点工作或是最低频率工作------------------
        if (  gc.u32work_scan_maxcurrent_freq > gc.work_span_L +50 &&  gc.u32work_scan_maxcurrent_freq < gc.work_span_H -50)
        {
          gc.u8workscan_en=0;     //当压太紧时，工作在最大电流点，不扫频了
          gc.u32Current_freq = gc.u32work_scan_maxcurrent_freq;
          gc.u16Work_check_time =5;           //当出现电流大于设定值10%时，调频周期设置为 10ms 进入慢调  
        }
        else
        {
          gc.u8workscan_en=0;     //当压太紧时，工作在最大电流点，不扫频了
          gc.u32Current_freq = gc.work_span_L;        
          gc.u16Work_check_time =5;           //当出现电流大于设定值10%时，调频周期设置为 10ms 进入慢调 
        }
      }
      
      
    
      if (    gc.u8workscan_en==0   )  //不扫频  根据相位调频
      {
        if ( gc.s32phase_check_av_val < 150 
            && gc.s32phase_check_av_val>-800 
            && gc.u8phase_check_val_yn==1 )
        {
          if ( gc.s32phase_check_av_val <  -170 )//
          {
            gc.u32Current_freq -=5;
            
            if(  gc.u32Current_freq <= gc.work_span_L   ) //压得太松或振子频率向下
            {
              gc.u32Current_freq = gc.work_span_L;
            }
          }
          else if ( gc.s32phase_check_av_val > -130)// 
          {
            if (  gc.s32phase_check_av_val < gc.s32phase_check_av_last_val )
            {
              if ( gc.u8work_freq_adj_pn  ==0 )         //工作频率调整方向 0 默认方向 1 反方向 
              {
                gc.u32Current_freq +=5;
              }
              if ( gc.u8work_freq_adj_pn  ==1 )         //工作频率调整方向 0 默认方向 1 反方向 
              {
                gc.u32Current_freq -=5;
              }                
            }
            if (  gc.s32phase_check_av_val > gc.s32phase_check_av_last_val )
            {
              if ( gc.u8work_freq_adj_pn  ==0 )         //工作频率调整方向 0 默认方向 1 反方向 
              {
                gc.u8work_freq_adj_pn  =1;
                gc.u32Current_freq -=5;
              }
              if ( gc.u8work_freq_adj_pn  ==1 )         //工作频率调整方向 0 默认方向 1 反方向 
              {
                gc.u8work_freq_adj_pn  =0;
                gc.u32Current_freq +=5;
              }                
            }            
 
          }        
        }
          
        gc.s32phase_check_av_last_val = gc.s32phase_check_av_val;     
      }            

}

void work_offset_adj( void )  //校准offset   恒阶段
{
    u16 i;
    u32 FREQ_MAX;
    u32 FREQ_MIN;
    u32 FREQ_ERR;
    u32 FREQ_AV;    
    

//---------------------检查10个周期内频率变化< 5hz 
    FREQ_MAX=0;
    FREQ_MIN=gc.work_span_H; 
    FREQ_AV=0;
    
    for  ( i=0;i<10;i++  )
    {
      if ( gc.u32Freq_old[i] > FREQ_MAX)
      {
        FREQ_MAX=gc.u32Freq_old[i];
      }
      if ( gc.u32Freq_old[i] < FREQ_MIN)
      {
        FREQ_MIN=gc.u32Freq_old[i];
      }
      FREQ_AV +=gc.u32Freq_old[i]; 
    }
    FREQ_ERR= FREQ_MAX-FREQ_MIN;//频率波动
    
    FREQ_AV=FREQ_AV/i;          //求平均值
    
    if ( FREQ_ERR < 40  )       //频率波动<4hz
    {
      if ( gc.u8offset_adj_F ==0 )
      {
        gc.u8offset_adj_F =1;
        
        gc.u32work_Constant_freq_freq = FREQ_AV;      
        
        
        gc.s16work_solder_freq_error=gc.u32work_Constant_freq_freq-gc.first_scan_Result_freq;       //相对串联谐振点的频率偏差振子压力是高低  

        if (  gc.s16work_solder_freq_error  < 250 &&  gc.s16work_solder_freq_error  > 50  )//&& gc.s32phase_check_av_val<0  &&  gc.u8phase_check_val_yn==1  )  //正常范围  +20hz-10hz
        {
          gc.s32work_freq_err=gc.u32work_Constant_freq_freq-gc.first_scan_Result_freq;  //调整频率偏移值到频率中心
          
          gc.s32work_freq_offset = gc.s32work_freq_err;

          gc.s8work_freq_offset_adj_F=1;   //工作频率修正值 更新标志 0未修正过 ，   1未修正过  
          
          err_handle(666);         //报错误代码 振子正常压力
        }
        else if (  gc.s16work_solder_freq_error  <= 350 )//振子偏紧
        {
          gc.s32work_freq_err=gc.u32work_Constant_freq_freq-gc.first_scan_Result_freq;  //调整频率偏移值到频率中心
          
          gc.s32work_freq_offset = gc.s32work_freq_err;          
          
          err_handle(10016);         //报错误代码 振子偏紧 

        }
        else if (  gc.s16work_solder_freq_error  >= -5 )//振子偏松
        {
          gc.s32work_freq_err=gc.u32work_Constant_freq_freq-gc.first_scan_Result_freq;  //调整频率偏移值到频率中心
          
          gc.s32work_freq_offset = gc.s32work_freq_err;          
          
          err_handle(10017);       //报错误代码 振子偏松
        }        
        else if (  gc.s16work_solder_freq_error  >= 350 )//振子压太紧
        {
          err_handle(10019);         //报错误代码 振子压太紧 

        }
        else if (  gc.s16work_solder_freq_error  <= -5 )//振子压太松
        {
          err_handle(10020);       //报错误代码 振子压太松
        }         

             
      }
    }
    
    
    
    
    
    
    

    
    
    
    
//-----------------------------在第10次恒相位点校正漂移并-----------------------------        

//      gc.u32Freq_old_av=gc.u32Current_freq;
//      
//      gc.s32work_freq_err=gc.u32Freq_old_av-(gc.work_span_H+gc.work_span_L)/2;//正常范围  
//      
//      if ( gc.s32work_freq_err < 0 )//表示谐振频率偏低
//      {
//        
//  
//        if (  gc.test_key_statu==0 )            //在remote 下 测试按键下调整gc.s32first_freq_offset 
//        {
//          gc.s32first_freq_offset +=10;
//        } 
//        else                                    //在remote 下 测试按键下调整gc.s32work_freq_offset
//        {
//          gc.s32work_freq_offset = gc.s32first_freq_offset+gc.s32work_freq_offset;
//          gc.s32first_freq_offset=0;
//          gc.s32work_freq_offset +=10;
//        }
//      } 
//      if ( gc.s32work_freq_err > 0 )//表示谐振频率偏高
//      {
//        if (  gc.test_key_statu==0 )            //在remote 下 测试按键下调整gc.s32first_freq_offset 
//        {
//          gc.s32first_freq_offset -=10;
//        } 
//        else                                    //在remote 下 测试按键下调整gc.s32work_freq_offset
//        {
//          gc.s32work_freq_offset = gc.s32first_freq_offset+gc.s32work_freq_offset;
//          gc.s32first_freq_offset=0;
//          gc.s32work_freq_offset -=10;
//        }        
//      } 
//
//      gc.s32work_ref_freq=  gc.first_scan_Result_freq+gc.s32first_freq_offset+gc.s32work_freq_offset;   //工作参考频率 
//      gc.work_span_H=gc.s32work_ref_freq+300;      //工作范围上限
//      gc.work_span_L=gc.s32work_ref_freq-100;      //工作范围下限            

}


//电源分为短发波长发波，当焊接时间设置>5s时按常发波


//==============================================================================
void run_test( void )
{       
  u16 i;

//  gc.s16power_set_val =30;//设定功率
  
//  gc.u16DC_volt_set = gc.s16power_set_val ; //设置电压


  gc.s32Work_phase =gc.first_scan_Result_phase; //设定相位
  
//==========  防止追频失败，频率跑飞================
  if (  gc.first_scan_Result_freq > gc.u32sysfreq*gc.Freq_adj_FBL*21/20 )
  {
    gc.first_scan_Result_freq = gc.u32sysfreq*gc.Freq_adj_FBL;    
  }
  if (  gc.first_scan_Result_freq <=  gc.u32sysfreq*gc.Freq_adj_FBL*19/20  )
  {
    gc.first_scan_Result_freq = gc.u32sysfreq*gc.Freq_adj_FBL;
  }
//------------------------------------------------- 
//=======================  更新 last================
  if (  gc.s32work_lsat_freq > gc.first_scan_Result_freq+1000)
  {
    gc.s32work_lsat_freq = gc.first_scan_Result_freq+200;
  }
  if (  gc.s32work_lsat_freq <=  gc.first_scan_Result_freq-1000  )
  {
    gc.s32work_lsat_freq = gc.first_scan_Result_freq+200;
  }    

//=======================test 状态范围宽一点====================================

  gc.s32first_freq_offset=0;
  gc.s32work_ref_freq=  gc.first_scan_Result_freq +150;   //工作参考频率 

  gc.work_span_H=gc.s32work_ref_freq+300;      //工作范围上限
  gc.work_span_L=gc.s32work_ref_freq-300;      //工作范围下限   
  
  gc.u32Current_freq  = gc.work_span_H;//加偏移值的定频工作
  

  gc.s8first_freq_offset_adj_F=0;     //追频修正标志 0未修正过 ，   1未修正过 
  gc.s8work_freq_offset_adj_F=0;   //工作频率修正值 更新标志 0未修正过 ，   1未修正过
  
  gc.s32work_FeedCurrent_limit_F =0;   //当前振子电流超过最大值限制 0正常 1超
  
  gc.u8phase_val_true=0;               //锁相状态0未进入1进入

  gc.s32phase_check_filish =0;          //清数据检查完成标志

  gc.u8phase_adj_F=0;           //未扫到正常谐振区域
  
  gc.u8phase_check_val_yn =0;
  
  gc.s32phase_check_av_last_val=0;//最后一次正确相位值
  
  gc.s32phase_check_av_last_updata_F=0;//最后一次正确相位值被更新的标志 1被更新
 
  
  gc.time_delay_filish =0;              //复位扫频延时 
  gc.time_delay_filish_last=0;
  
  gc.u16Scan_current_1ms_cnt=0;         //电流检测时间清零  
  
  gc.u8workscan_en=0;                   //允许降频扫描位
  
  gc.u8work_freq_adj_pn=0;              //工作频率调整方向 0 默认方向 1 反方向 
  
  gc.Work_check_en=0;                   //频率跟踪使能 0 完成跟踪 1启动跟踪
  
  gc.Work_check_f=0;                    //频率跟踪状态 0 未跟踪 1完成跟踪
  
  gc.u16Work_check_time_cnt=0;          //校准周期计数器清零    

  gc.u16Work_check_time =3;           //调频周期设置为 2ms 初始2ms调整一次频率

//  gc.u32work_Constant_freq=0;
  
  
  gc.Freq_adj_val  =10;                //在工作状态追频默认0.5hz  1/ gc.Freq_adj_FBL  0.1hz 
  
  gc.u8over_power_F=0;

  gc.u8offset_adj_F=0;  
  
  gc.s16work_solder_freq_error=0;
//  gc.s32work_scan_oc1_freq=0;           //工作时向下扫频 ，第一次触碰到设定功率点时的频率
//  gc.u8work_scan_oc1_freq_updata_F=0;   //工作时向下扫频 ，第一次触碰到设定功率点时的频率更新标志
  
  
  gc.s16work_solder_freq_error=0;       //振子压力是高低

//------------点焊功率限制------------------------- 
  
  gc.u32work_current_sum =0;// 进入test状态后功率累加值 
  gc.u16work_on_cnt=0;

  
  gc.u16cph_cnt=0;//恒相位计时清零
  
  gc.s16cp_cnt=0;//恒功率计时清零

  gc.u8work_ovp_F=0;            // 过功率保护标志 
  

  
  
//---------------------------------焊接全程------------------------------------  
  
  gc.u16work_cnt=0;////发波过程按时序工作，  
  gc.u8pressing_down_F=0;
  gc.u8solding_F=0;
  gc.u8work_overtime_F=0;
  gc.u8press_holding_F=0;
  

//----------------------------------------------------------------------------- 

  
  for( i=0; i<155; i++ )
  {
    gc.u32Freq_old[i] = 0;
  }
  gc.u16Freq_old_index=0;
  
  for( i=0; i<155; i++ )
  {
    gc.s32phase_old[i] = 0;
  }
  gc.u16phase_old_index=0;  
  
  for( i=0; i<155; i++ )
  {
    gc.u32Adc_CH4[i] = 0;
  } 
  for( i=0; i<155; i++ )
  {
    gc.u32Adc_CH5[i] = 0;
  }   
  

//  gc.s32work_volt_K=0;   //修正值复位
//  gc.display_mode=3;

}


void sys_test( void )
{

static  s32 s32adsumA ;
         u16 i;      
         u16 u16ADC_val;

   if( gc.u16Scan_current_1ms_cnt <1 )   // 2ms 进入
   {  return; }
   gc.u16Scan_current_1ms_cnt = 0;      //清零
   
//==============================开始时序控制-=========================
    
  if (  gc.u16work_cnt <= gc.u16pressing_down_time + 5) //当下降时间设定为零时，保证进入后开电磁阀
  {
    E_VALVE_cmd( ENABLE );
    gc.u8pressing_down_F=1;    
  }
  
  if ( gc.u16work_cnt > gc.u16pressing_down_time && gc.u16work_cnt <= gc.u16pressing_down_time +gc.u32sold_time  )
  {
    gc.u8solding_F=1;
  }
  
  if ( gc.u16work_cnt > gc.u16pressing_down_time + 30 && gc.u16work_cnt <= gc.u16pressing_down_time +gc.u32sold_time  ) //30ms前置稳定时间
  {
    gc.time_delay_filish =1;              //复位扫频延时     
  }

  if ( gc.u16work_cnt > gc.u16pressing_down_time +gc.u32sold_time  && gc.u16work_cnt <= gc.u16pressing_down_time +gc.u32sold_time +gc.u16press_holding_time +5 )
  {
    gc.u8solding_F=0;
//    gc.u8work_overtime_F=1;
    gc.u8press_holding_F=1;
  }
  
  if (  gc.u16work_cnt > gc.u16pressing_down_time +gc.u32sold_time +gc.u16press_holding_time +10 )
  {
    E_VALVE_cmd( DISABLE );
    gc.u8solding_F=0;
    gc.Work_cmd =0;             //结束一个工作循环
  }
  
  if (  gc.u16work_cnt > 20000  )
  {
    gc.u16work_cnt =20000;      //=10000个周期    
  }
  
  

//==============================================================================  

//------------------在发波阶段开uc3846------------------------------------------  
   
    if ( gc.u8solding_F==1 )
    {
      WAVE_OUTPUT_cmd( ENABLE);   
    }
    else
    {
      WAVE_OUTPUT_cmd( DISABLE);
    }

  if (  gc.u8solding_F==0  )
   {  return; }
  
//=========================发波阶段 走下面  焊接控制============================
  
//================================连续4次平均===================================

   u16ADC_val  = Read_Adc_value( ADC_Channel_4 );  //切换通道先才一次样丢掉
   s32adsumA = 0;      //1ms 进来读一次电流
   for( i=0; i<4; i++ )
   {
       u16ADC_val  = Read_Adc_value( ADC_Channel_4 );  //读电流值
       s32adsumA += (u32)u16ADC_val;  //
   }
   gc.s32work_FeedCurrent  = s32adsumA >>2;   
   
   u16ADC_val  = Read_Adc_value( ADC_Channel_5 );  //切换通道先才一次样丢掉
   s32adsumA = 0;      //1ms 进来读一次电流
   for( i=0; i<4; i++ )
   {
       u16ADC_val  = Read_Adc_value( ADC_Channel_5 );  //读电流值
       s32adsumA += (u32)u16ADC_val;  //
   }
   gc.s32FeedCurrent  = s32adsumA >>2;
   
//==============================================================================   
   
 
//--------------------------------移动赋值 ad 平均----------------------------------- 

//=====================================移动赋值 ad==============================     
   for( i=150; i>1; i-- )
   {
      gc.u32Adc_CH4[i-1] = gc.u32Adc_CH4[i-2];
   }   
   gc.u32Adc_CH4[0] =gc.s32work_FeedCurrent;
   
   s32adsumA =0;    
   for( i=0; i<2; i++ )
   {
     s32adsumA += gc.u32Adc_CH4[i];
   }
   gc.u32ch4_av_ms = s32adsumA/i;//2次移动平均   
   
//============================================================================
   for( i=150; i>1; i-- )
   {
      gc.u32Adc_CH5[i-1] = gc.u32Adc_CH5[i-2];
   }   
   gc.u32Adc_CH5[0] =gc.s32FeedCurrent;
   
   s32adsumA =0;    
   for( i=0; i<2; i++ )
   {
     s32adsumA += gc.u32Adc_CH5[i];
   }
   gc.u32ch5_av_ms = s32adsumA/i;//2次移动平均
//==============================================================================  

   

//==================输出级电流限制============================================== 
   if ( gc.s32work_FeedCurrent >= gc.s32work_FeedCurrent_limit_bit *12/8 )
   {
      WAVE_OUTPUT_cmd( DISABLE);
      E_VALVE_cmd( DISABLE );
      
      err_handle(10021);      //超过设定功率   过功率
      
      gc.u8work_ovp_F=0;      // 过功率保护标志     
      gc.Work_cmd =0; 
   }   
   else if ( gc.s32work_FeedCurrent >= gc.s32work_FeedCurrent_limit_bit  )
   {
      gc.u32Current_freq +=20;// 向上调2hz
      gc.s32work_FeedCurrent_limit_F =1;   //当前振子电流超过最大值限制 0正常 1超
   }
   else if (  gc.s32work_FeedCurrent >= gc.s32work_FeedCurrent_limit_bit *9/10 )
   {
      gc.u32Current_freq +=10;// 向上调1hz
      gc.s32work_FeedCurrent_limit_F =0;   //当前振子电流超过最大值限制 0正常 1超
   }
   else
   {
      gc.s32work_FeedCurrent_limit_F =0;   //当前振子电流超过最大值限制 0正常 1超
   }
 
   
   
   
   
   
   
//====================过功率  **********   ====================================================
  if (  gc.s32FeedCurrent >  1000  )
  {
    WAVE_OUTPUT_cmd( DISABLE);
    E_VALVE_cmd( DISABLE );
    
    err_handle(10013);      //超过设定功率   过功率 原边
    
    gc.u8work_ovp_F=0;          // 过功率保护标志     
    gc.Work_cmd =0;             //
  }


//------------------------启动工作延时完成,第1次进入 再恢复一次现场  -----------    
  if (  gc.time_delay_filish_last ==0  &&  gc.time_delay_filish==1) //只进一次 
  {
    gc.u32first_scan_current1 = gc.u32ch4_av_ms;//用于判断设定功率是否偏低
    
    if (  gc.s32work_FeedCurrent >  gc.s16power_set_inter_val*15/10  )        //可在这增加延时关机   
    {
      WAVE_OUTPUT_cmd( DISABLE);
      E_VALVE_cmd( DISABLE );
      
      err_handle(10018);                //报错误代码 振子压得太紧谐振频率到达工作频率上限太多或者短路了
      
      gc.u8work_ovp_F=0;                // 过功率保护标志     
      gc.Work_cmd =0;                   //
    }    
    
    if (  gc.s32work_FeedCurrent >  gc.s16power_set_inter_val*15/10  )        //可在这增加延时关机   
    {
      WAVE_OUTPUT_cmd( DISABLE);
      E_VALVE_cmd( DISABLE );
      
      err_handle(10018);                //报错误代码 振子压得太紧谐振频率到达工作频率上限太多或者短路了
      
      gc.u8work_ovp_F=0;                // 过功率保护标志     
      gc.Work_cmd =0;                   //
    }     
    
    gc.u8workscan_en=1;                 //允许降频扫描位    
    
    gc.u16Work_check_time_cnt=0;        //复位计数器，数据稳定后，下次再运行下面的程序
    
    gc.u32work_scan_av_current_max = 0;
    gc.u32work_scan_av_current_min =300;//进入扫描后移动平均电流值最小值
    gc.u32work_scan_maxcurrent_freq = gc.s32work_ref_freq;//赋初值
    gc.u32work_scan_mincurrent_freq = gc.s32work_ref_freq;//赋初值          

  }
  gc.time_delay_filish_last = gc.time_delay_filish;
  
/*
*  在测试状态可能出现场景：设备在调试阶段，第一次启动设备联调，蒸制压力没调好
*  状况  1太松 2偏松 3合适 4偏紧 5太紧 6开路 7短路 8已经按过一次test 第二次按频率会低
*  
*  
*  
*   
*/
  
//----------------------按周期修正频率--------------------------------------------     

  if ( gc.time_delay_filish==1  &&  gc.u16Work_check_time_cnt>= gc.u16Work_check_time )
  {
    gc.u16Work_check_time_cnt=0;
    gc.Work_check_en=1;                   //频率跟踪使能 0 完成跟踪 1启动跟踪
    gc.Work_check_f=0;                    //频率跟踪状态 0 未完成跟踪 1完成跟踪
  }
  
  


  
  
//=========================功率闭环=============================================  
//-------------------------修改调整周期 接近谐振点时放慢速度-----------------------------------------
  
  if(  gc.u8over_power_F==0 )
  {
    if (  ( gc.s32work_FeedCurrent >  gc.s16power_set_inter_val*6/8 &&  gc.s32work_FeedCurrent <  gc.s16power_set_inter_val*10/8 )  ) // +- 1/8
    {
      gc.u16Work_check_time =10;           //当出现电流大于设定值10%时，调频周期设置为 10ms 进入慢调  
      gc.Freq_adj_val=5;  
    }
    else if (  ( gc.s32work_FeedCurrent >  gc.s16power_set_inter_val*7/8 &&  gc.s32work_FeedCurrent <  gc.s16power_set_inter_val*9/8 )  ) // +- 2/8
    {
      gc.u16Work_check_time =5;           //当出现电流大于设定值10%时，调频周期设置为 10ms 进入中速调 
      gc.Freq_adj_val=8;
    }  
    else
    {
      gc.u16Work_check_time =5;           //当出现电流大于设定值10%时，调频周期设置为 10ms 进入快速调 
      gc.Freq_adj_val=10;
    }  
  }
  else
  {
      gc.u16Work_check_time =10;           //当出现电流大于设定值10%时，调频周期设置为 10ms 进入快速调 
      gc.Freq_adj_val=5;  
  }
  

 
 
  
  
  
  
  
  
  
  
  
  
 
  if (  gc.Work_check_en==1  )          //延时到了就开始采样 连续采样 
  {
//------------------------采相位-----------------------     
    phase_sample();                     //相位采集
    
//------------------------移动存储过程相位/过程频率-----------------------     
    save_f_ph();                        //移动存储过程相位/过程频率
    
//----------------------过电流（过功率）调高频率--------------------------------  
    if (  gc.s32work_FeedCurrent >  gc.s16power_set_inter_val  )  // //超过设定功率+- 1/16 当接近设置功率时
    {
      over_power(); //超过设定功率
    } 
    
//-------------------------低于设定功率 降频扫描或调相---------------------------------------------   
    else if ( gc.s32work_FeedCurrent <  gc.s16power_set_inter_val )  //  +- 1/10降频扫描位  功率小
    {
      Fscan_or_phaseadj();//扫频或调相 
    }
    
//------------------------校准work_offset----------------------------------------    
    work_offset_adj();                          //校准work_offset

    
    
    gc.Work_check_en=0;
    
  } 
  
  

  
//========================================调硬件漂移量 =========================== 
  
  
  
  
  
  
//-----------以相位闭环   能正常采到相位同时高与谐振频率，这时关闭降频----------
//  
//  else  if ( gc.Work_check_en==1 && gc.u8phase_check_val_yn==1 && gc.s32phase_check_av_val<150  && gc.s32phase_check_av_val > -750  )  
//  {
//      if ( gc.s32phase_check_av_val <  -170 )//
//      {
//        gc.u32Current_freq -=10;
//        
//        if(  gc.u32Current_freq <= gc.work_span_L   ) //压得太松或振子频率向下
//        {
//          gc.u32Current_freq = gc.work_span_L;
//        }
//      }
//      else if ( gc.s32phase_check_av_val > -130)// 
//      {
//
//        gc.u32Current_freq +=10;
//         if (  gc.u32Current_freq >= gc.work_span_H )
//        {
//          gc.u32Current_freq=gc.work_span_H; 
//        } 
//      }
//      
//      gc.u8workscan_en=0;                   //禁止降频扫描位
//  }

  
  




  
//=========================判断频率偏移量是否合适=== 
/*条件
  
  work后第100ms-150ms频率平均值大于gc.work_span_L+50   && 小于gc.work_span_L-100
  相位在<0  >-200

  在刚开始的时候谐振频率会因为压力大而偏高，当熔接时频率会降低
  
*/  
  
////=============================求出平均频率 平均相位 ================================= 
//  
//  if ( gc.u16Freq_old_index == 75 )
//  {
//    gc.u32Freq_old_sum=0;            //工作时的频率累加值100ms-150ms 
//    for( i=49; i<74; i++ )
//   {
//     gc.u32Freq_old_sum += gc.u32Freq_old[i];
//   }
//   gc.u32Freq_old_av = gc.u32Freq_old_sum/25;// 25次循环  50ms移动平均
//  }
//  
//
//  if ( gc.u16phase_old_index == 75 )
//  {
//    gc.s32phase_old_sum=0;            //工作时的频率累加值100ms-150ms 
//    for( i=49; i<74; i++ )
//   {
//     gc.s32phase_old_sum += gc.s32phase_old[i];
//   }
//   gc.s32phase_old_av = gc.s32phase_old_sum/25;// 25次循环  50ms移动平均
//  }  
//  
////=====================================================================================
//
//
//  if ( gc.u16phase_old_index == 75 && gc.s32phase_check_av_last_updata_F==1)
//  {
//    gc.s32work_freq_err=gc.u32Freq_old_av-(gc.work_span_H+gc.work_span_L)/2+50;//正常范围   
//    gc.display_mode_last=gc.display_mode;//保存当前的模式值，用于返回到上次的显示值
// 
//    
//    
//    
//    
//    
//    
//    
//    
//    
//    
////    gc.display_mode=3; 
////    //========================
////    gc.display_reset_cn =0;
////    gc.display_reset_cmd=1;         //定时复位显示功率
////    gc.display_reset_time=2000;         //显示恢复时间  5秒  
//    
//    
////--------------------------------判断状态并调整偏移量------
//    
//    if (  gc.test_key_statu==0 ) 
//    {
//      if ( gc.s32work_freq_err < 0 )//表示谐振频率偏低
//      {
//
// //        gc.s32first_freq_offset +=10;
//      } 
//      if ( gc.s32work_freq_err > 0 )//表示谐振频率偏高
//      {
//
////         gc.s32first_freq_offset -=10;
//      }       
//    }
//
//      
//   
//      
//  }
//  else if ( gc.u16phase_old_index == 75 && gc.s32phase_check_av_last_updata_F==0 )
//  {
//    gc.display_mode_last=gc.display_mode;//保存当前的模式值，用于返回到上次的显示值
// 
//    
//  }    
    
    
    
    
    
    
    
//    gc.display_mode=4; 
//    //========================
//    gc.display_reset_cn =0;
//    gc.display_reset_cmd=1;         //定时复位显示功率
//    gc.display_reset_time=5000;         //显示恢复时间  5秒  


////---------------------V_K  加限制-------------------------------
//  if ( gc.s32work_volt_K + (s32)gc.u16DC_volt_set <5  )
//  {
//    gc.s32work_volt_K =5-(s32)gc.u16DC_volt_set ;
//  }
//  if ( gc.s32work_volt_K +(s32)gc.u16DC_volt_set  >120  )//本机器最大输出直流120V
//  {
//    gc.s32work_volt_K =120-(s32)gc.u16DC_volt_set;
//  }
//--------------------------------------------------------------
  
  
  
  
  

//---------------------振子频率漂移 gc.s32first_freq_offset 加限制-------------
  
  if ( gc.s32first_freq_offset >1500 )
  {
    gc.s32first_freq_offset=1500;
  }
  
  if ( gc.s32first_freq_offset <-1500 )
  {
    gc.s32first_freq_offset=-1500;
  }  
  
//------------------------------------------------------------------------  
  
//---------------------振子频率漂移 gc.s32work_freq_offset 加限制-------------
  
  if ( gc.s32work_freq_offset >1000 )
  {
    gc.s32work_freq_offset=1000;
  }
  
  if ( gc.s32work_freq_offset <-1000 )
  {
    gc.s32work_freq_offset=-1000;
  }    
  


//----------------------限频---------------------------------------------     
  
  

  if (  gc.u32Current_freq >= gc.work_span_H )
  {
    gc.u32Current_freq = gc.work_span_H;
  }
  if (  gc.u32Current_freq <= gc.work_span_L   )
  {
    gc.u32Current_freq = gc.work_span_L;
  }   

//----------------------------------------------------------------------------


     
}



